E155 Lab 2: Multiplexed 7-Segment Display - Time-Division Multiplexing

// 7-segment display multiplexing implementation
// Optimized for flicker-free operation
#include "display.h"

// Segment patterns for digits 0-9
const uint8_t digit_patterns[10] = {
    0x3F,  // 0: segments a,b,c,d,e,f
    0x06,  // 1: segments b,c
    0x5B,  // 2: segments a,b,g,e,d
    0x4F,  // 3: segments a,b,g,c,d
    0x66,  // 4: segments f,g,b,c
    0x6D,  // 5: segments a,f,g,c,d
    0x7D,  // 6: segments a,f,g,e,d,c
    0x07,  // 7: segments a,b,c
    0x7F,  // 8: all segments
    0x6F   // 9: segments a,b,c,d,f,g
};

// Display buffer for 4 digits
uint8_t display_buffer[4] = {0, 0, 0, 0};
uint8_t current_digit = 0;

void display_update(void) {
    // Turn off all digits
    DIGIT_SELECT = 0x00;
    
    // Set segment pattern for current digit
    SEGMENT_DATA = digit_patterns[display_buffer[current_digit]];
    
    // Enable current digit
    DIGIT_SELECT = (1 << current_digit);
    
    // Move to next digit
    current_digit = (current_digit + 1) % 4;
}

// Timer interrupt for display refresh
void timer_isr(void) {
    // Update display every 1ms
    display_update();
    
    // Clear timer interrupt flag
    TIMER_STATUS |= TIMER_INT_CLEAR;
}

// Initialize display system
void display_init(void) {
    // Configure GPIO for segments and digits
    SEGMENT_PORT_DIR = 0xFF;    // All segments as outputs
    DIGIT_PORT_DIR = 0x0F;      // 4 digits as outputs
    
    // Initialize display buffer
    for (int i = 0; i < 4; i++) {
        display_buffer[i] = 0;
    }
    
    // Configure timer for 1ms interrupts
    TIMER_PERIOD = 1000;        // 1ms period
    TIMER_CONTROL = TIMER_ENABLE | TIMER_INT_ENABLE;
}

// Set a specific digit value
void display_set_digit(uint8_t digit, uint8_t value) {
    if (digit < 4 && value < 10) {
        display_buffer[digit] = value;
    }
}

// Display a 4-digit number
void display_number(uint16_t number) {
    display_buffer[0] = (number / 1000) % 10;
    display_buffer[1] = (number / 100) % 10;
    display_buffer[2] = (number / 10) % 10;
    display_buffer[3] = number % 10;
}

// Clear all digits
void display_clear(void) {
    for (int i = 0; i < 4; i++) {
        display_buffer[i] = 0;
    }
}

// Display a string (limited to 4 characters)
void display_string(const char* str) {
    display_clear();
    for (int i = 0; i < 4 && str[i] != '\0'; i++) {
        if (str[i] >= '0' && str[i] <= '9') {
            display_buffer[i] = str[i] - '0';
        }
    }
}

// Optimized multiplexing with proper timing
void display_update_optimized(void) {
    static uint32_t last_update = 0;
    uint32_t current_time = get_system_tick();
    
    // Update every 1ms for smooth display
    if (current_time - last_update >= 1) {
        // Turn off all digits first
        DIGIT_SELECT = 0x00;
        
        // Set segment pattern
        SEGMENT_DATA = digit_patterns[display_buffer[current_digit]];
        
        // Enable current digit
        DIGIT_SELECT = (1 << current_digit);
        
        // Move to next digit
        current_digit = (current_digit + 1) % 4;
        
        last_update = current_time;
    }
}

// Brightness control through PWM-like operation
void display_set_brightness(uint8_t brightness) {
    // Brightness: 0-100 (percentage)
    if (brightness > 100) brightness = 100;
    
    // Calculate on-time based on brightness
    display_on_time = (brightness * DISPLAY_PERIOD) / 100;
    display_off_time = DISPLAY_PERIOD - display_on_time;
}

// Enhanced display update with brightness control
void display_update_with_brightness(void) {
    static uint32_t digit_start_time = 0;
    uint32_t current_time = get_system_tick();
    
    // Check if it's time to switch digits
    if (current_time - digit_start_time >= display_on_time) {
        // Turn off current digit
        DIGIT_SELECT = 0x00;
        
        // Wait for off-time
        if (current_time - digit_start_time >= DISPLAY_PERIOD) {
            // Move to next digit
            current_digit = (current_digit + 1) % 4;
            
            // Set new digit pattern
            SEGMENT_DATA = digit_patterns[display_buffer[current_digit]];
            DIGIT_SELECT = (1 << current_digit);
            
            digit_start_time = current_time;
        }
    }
}

// Anti-flicker display update
void display_update_anti_flicker(void) {
    static uint32_t last_update = 0;
    static uint8_t update_phase = 0;
    uint32_t current_time = get_system_tick();
    
    // Update at precise intervals
    if (current_time - last_update >= 1) {
        switch (update_phase) {
            case 0: // Turn off all digits
                DIGIT_SELECT = 0x00;
                break;
                
            case 1: // Set segment data
                SEGMENT_DATA = digit_patterns[display_buffer[current_digit]];
                break;
                
            case 2: // Enable current digit
                DIGIT_SELECT = (1 << current_digit);
                current_digit = (current_digit + 1) % 4;
                break;
        }
        
        update_phase = (update_phase + 1) % 3;
        last_update = current_time;
    }
}

// Comprehensive test suite for display functions
void test_display_functions(void) {
    // Test digit patterns
    test_digit_patterns();
    test_display_timing();
    
    // Test multiplexing
    test_multiplexing_sequence();
    test_brightness_control();
    
    // Test user interface
    test_number_display();
    test_string_display();
}

bool test_digit_patterns(void) {
    // Test all digit patterns 0-9
    for (int digit = 0; digit < 10; digit++) {
        display_set_digit(0, digit);
        delay_ms(100);
        
        // Verify correct segment pattern
        if (SEGMENT_DATA != digit_patterns[digit]) {
            return false;
        }
    }
    return true;
}

bool test_multiplexing_sequence(void) {
    // Test digit switching sequence
    uint8_t expected_digit = 0;
    
    for (int i = 0; i < 20; i++) { // Test 5 complete cycles
        display_update();
        delay_ms(1);
        
        // Check if correct digit is enabled
        if (DIGIT_SELECT != (1 << expected_digit)) {
            return false;
        }
        
        expected_digit = (expected_digit + 1) % 4;
    }
    return true;
}

// Decimal point control for each digit
uint8_t decimal_points = 0; // Bit mask for decimal points

void display_set_decimal(uint8_t digit, bool enable) {
    if (digit < 4) {
        if (enable) {
            decimal_points |= (1 << digit);
        } else {
            decimal_points &= ~(1 << digit);
        }
    }
}

// Enhanced display update with decimal points
void display_update_with_decimals(void) {
    // Turn off all digits
    DIGIT_SELECT = 0x00;
    
    // Get segment pattern for current digit
    uint8_t pattern = digit_patterns[display_buffer[current_digit]];
    
    // Add decimal point if enabled
    if (decimal_points & (1 << current_digit)) {
        pattern |= 0x80; // Set decimal point bit
    }
    
    // Set segment data
    SEGMENT_DATA = pattern;
    
    // Enable current digit
    DIGIT_SELECT = (1 << current_digit);
    
    // Move to next digit
    current_digit = (current_digit + 1) % 4;
}

// Scrolling text display
char scroll_text[] = "HELLO WORLD";
uint8_t scroll_position = 0;
uint32_t scroll_timer = 0;

void display_scroll_text(void) {
    static uint32_t last_scroll = 0;
    uint32_t current_time = get_system_tick();
    
    // Scroll every 500ms
    if (current_time - last_scroll >= 500) {
        // Display 4 characters starting at scroll_position
        for (int i = 0; i < 4; i++) {
            char c = scroll_text[(scroll_position + i) % strlen(scroll_text)];
            if (c >= '0' && c <= '9') {
                display_buffer[i] = c - '0';
            } else {
                display_buffer[i] = 0; // Blank for non-numeric
            }
        }
        
        // Move scroll position
        scroll_position = (scroll_position + 1) % strlen(scroll_text);
        last_scroll = current_time;
    }
}

// Display integration with system functions
void system_status_display(void) {
    // Display system information
    display_number(get_system_voltage());
    display_set_decimal(1, true); // Show decimal point
    
    // Update every second
    static uint32_t last_update = 0;
    if (get_system_tick() - last_update >= 1000) {
        display_number(get_cpu_temperature());
        last_update = get_system_tick();
    }
}

// Usage in main application
int main(void) {
    display_init();
    
    while (1) {
        // Update display
        display_update();
        
        // Show system status
        system_status_display();
        
        // Handle other tasks
        process_user_input();
    }
}